//+------------------------------------------------------------------+
//|                                            processthreadsapi.mqh |
//|                             Copyright 2000-2025, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#include <WinAPI/windef.h>
#include <WinAPI/winnt.h>

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
// 线程信息类别
enum THREAD_INFORMATION_CLASS
{
   ThreadMemoryPriority,           // 线程内存优先级
   ThreadAbsoluteCpuPriority,      // 线程绝对CPU优先级
   ThreadDynamicCodePolicy,        // 线程动态代码策略
   ThreadPowerThrottling,          // 线程电源节流
   ThreadInformationClassMax       // 最大线程信息类别
};

// 进程信息类别
enum PROCESS_INFORMATION_CLASS
{
   ProcessMemoryPriority,          // 进程内存优先级
   ProcessMemoryExhaustionInfo,    // 进程内存耗尽信息
   ProcessAppMemoryInfo,           // 进程应用内存信息
   ProcessInPrivateInfo,           // 进程隐私信息
   ProcessPowerThrottling,         // 进程电源节流
   ProcessReservedValue1,          // 保留值1
   ProcessTelemetryCoverageInfo,   // 进程遥测覆盖信息
   ProcessProtectionLevelInfo,     // 进程保护级别信息
   ProcessInformationClassMax      // 最大进程信息类别
};

// 进程内存耗尽类型
enum PROCESS_MEMORY_EXHAUSTION_TYPE
{
   PMETypeFailFastOnCommitFailure, // 提交失败时快速失败
   PMETypeMax                      // 最大值
};

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
// 进程信息结构
struct PROCESS_INFORMATION
{
   HANDLE hProcess;                // 进程句柄
   HANDLE hThread;                 // 主线程句柄
   uint dwProcessId;               // 进程ID
   uint dwThreadId;                // 线程ID
};

// 启动信息结构
struct STARTUPINFOW
{
   uint cb;                        // 结构大小
   string lpReserved;              // 保留字段
   string lpDesktop;               // 桌面名称
   string lpTitle;                 // 控制台标题
   uint dwX;                       // 窗口X位置
   uint dwY;                       // 窗口Y位置
   uint dwXSize;                   // 窗口宽度
   uint dwYSize;                   // 窗口高度
   uint dwXCountChars;             // 控制台宽度(字符)
   uint dwYCountChars;             // 控制台高度(字符)
   uint dwFillAttribute;           // 控制台填充属性
   uint dwFlags;                   // 启动标志
   ushort wShowWindow;             // 窗口显示状态
   ushort cbReserved2;             // 保留字段2大小
   PVOID lpReserved2;              // 保留字段2
   HANDLE hStdInput;               // 标准输入句柄
   HANDLE hStdOutput;              // 标准输出句柄
   HANDLE hStdError;               // 标准错误句柄
};

// 内存优先级信息
struct MEMORY_PRIORITY_INFORMATION
{
   uint MemoryPriority;            // 内存优先级值
};

// 线程电源节流状态
struct THREAD_POWER_THROTTLING_STATE
{
   uint Version;                   // 结构版本
   uint ControlMask;               // 控制掩码
   uint StateMask;                 // 状态掩码
};

// 应用内存信息
struct APP_MEMORY_INFORMATION
{
   ulong AvailableCommit;          // 可用提交内存
   ulong PrivateCommitUsage;       // 私有提交内存使用量
   ulong PeakPrivateCommitUsage;   // 峰值私有提交内存使用量
   ulong TotalCommitUsage;         // 总提交内存使用量
};

// 进程内存耗尽信息
struct PROCESS_MEMORY_EXHAUSTION_INFO
{
   ushort Version;                 // 结构版本
   ushort Reserved;                // 保留字段
   PROCESS_MEMORY_EXHAUSTION_TYPE Type; // 内存耗尽类型
   ulong Value;                    // 相关值
};

// 进程电源节流状态
struct PROCESS_POWER_THROTTLING_STATE
{
   uint Version;                   // 结构版本
   uint ControlMask;               // 控制掩码
   uint StateMask;                 // 状态掩码
};

// 进程保护级别信息
struct PROCESS_PROTECTION_LEVEL_INFORMATION
{
   uint ProtectionLevel;           // 保护级别
};

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
#import "kernel32.dll"
/// 将APC添加到线程队列
/// @param apc APC函数指针
/// @param thread 线程句柄
/// @param data APC参数
/// @return 操作结果
uint QueueUserAPC(PVOID apc, HANDLE thread, ulong data);

/// 获取进程时间信息
/// @param process 进程句柄
/// @param creation_time 创建时间
/// @param exit_time 退出时间
/// @param kernel_time 内核时间
/// @param user_time 用户时间
/// @return 操作结果
int GetProcessTimes(HANDLE process, FILETIME &creation_time, FILETIME &exit_time, FILETIME &kernel_time, FILETIME &user_time);

/// 获取当前进程句柄
/// @return 当前进程伪句柄
HANDLE GetCurrentProcess(void);

/// 获取当前进程ID
/// @return 当前进程ID
uint GetCurrentProcessId(void);

/// 退出当前进程
/// @param exit_code 退出代码
void ExitProcess(uint exit_code);

/// 终止进程
/// @param process 进程句柄
/// @param exit_code 退出代码
/// @return 操作结果
int TerminateProcess(HANDLE process, uint exit_code);

/// 获取进程退出代码
/// @param process 进程句柄
/// @param exit_code 返回的退出代码
/// @return 操作结果
int GetExitCodeProcess(HANDLE process, uint &exit_code);

/// 切换到另一个就绪线程
/// @return 是否切换成功
int SwitchToThread(void);

/// 创建新线程
/// @param thread_attributes 线程安全属性
/// @param stack_size 堆栈大小
/// @param start_address 线程函数地址
/// @param parameter 线程参数
/// @param creation_flags 创建标志
/// @param thread_id 返回的线程ID
/// @return 线程句柄
HANDLE CreateThread(PVOID thread_attributes, ulong stack_size, PVOID start_address, PVOID parameter, uint creation_flags, uint &thread_id);

/// 在远程进程中创建线程
/// @param process 远程进程句柄
/// @param thread_attributes 线程安全属性
/// @param stack_size 堆栈大小
/// @param start_address 线程函数地址
/// @param parameter 线程参数
/// @param creation_flags 创建标志
/// @param thread_id 返回的线程ID
/// @return 线程句柄
HANDLE CreateRemoteThread(HANDLE process, PVOID thread_attributes, ulong stack_size, PVOID start_address, PVOID parameter, uint creation_flags, uint &thread_id);

/// 获取当前线程句柄
/// @return 当前线程伪句柄
HANDLE GetCurrentThread(void);

/// 获取当前线程ID
/// @return 当前线程ID
uint GetCurrentThreadId(void);

/// 打开现有线程
/// @param desired_access 访问权限
/// @param inherit_handle 是否可继承
/// @param thread_id 线程ID
/// @return 线程句柄
HANDLE OpenThread(uint desired_access, int inherit_handle, uint thread_id);

/// 设置线程优先级
/// @param thread 线程句柄
/// @param priority 优先级值
/// @return 操作结果
int SetThreadPriority(HANDLE thread, int priority);

/// 设置线程优先级提升状态
/// @param thread 线程句柄
/// @param disable_priority_boost 是否禁用优先级提升
/// @return 操作结果
int SetThreadPriorityBoost(HANDLE thread, int disable_priority_boost);

/// 获取线程优先级提升状态
/// @param thread 线程句柄
/// @param disable_priority_boost 返回的优先级提升状态
/// @return 操作结果
int GetThreadPriorityBoost(HANDLE thread, int &disable_priority_boost);

/// 获取线程优先级
/// @param thread 线程句柄
/// @return 线程优先级值
int GetThreadPriority(HANDLE thread);

/// 退出当前线程
/// @param exit_code 退出代码
void ExitThread(uint exit_code);

/// 终止线程
/// @param thread 线程句柄
/// @param exit_code 退出代码
/// @return 操作结果
int TerminateThread(HANDLE thread, uint exit_code);

/// 获取线程退出代码
/// @param thread 线程句柄
/// @param exit_code 返回的退出代码
/// @return 操作结果
int GetExitCodeThread(HANDLE thread, uint &exit_code);

/// 挂起线程
/// @param thread 线程句柄
/// @return 之前的挂起计数
uint SuspendThread(HANDLE thread);

/// 恢复线程
/// @param thread 线程句柄
/// @return 之前的挂起计数
uint ResumeThread(HANDLE thread);

/// 分配线程本地存储索引
/// @return TLS索引
uint TlsAlloc(void);

/// 获取线程本地存储值
/// @param tls_index TLS索引
/// @return 存储的值
PVOID TlsGetValue(uint tls_index);

/// 设置线程本地存储值
/// @param tls_index TLS索引
/// @param tls_value 要设置的值
/// @return 操作结果
int TlsSetValue(uint tls_index, PVOID tls_value);

/// 释放线程本地存储索引
/// @param tls_index TLS索引
/// @return 操作结果
int TlsFree(uint tls_index);

/// 创建新进程
/// @param application_name 应用程序名
/// @param command_line 命令行
/// @param process_attributes 进程安全属性
/// @param thread_attributes 线程安全属性
/// @param inherit_handles 是否继承句柄
/// @param creation_flags 创建标志
/// @param environment 环境变量
/// @param current_directory 当前目录
/// @param startup_info 启动信息
/// @param process_information 进程信息
/// @return 操作结果
int CreateProcessW(const string application_name, string command_line, PVOID process_attributes, PVOID thread_attributes, int inherit_handles, uint creation_flags, PVOID environment, const string current_directory, STARTUPINFOW &startup_info, PROCESS_INFORMATION &process_information);

/// 设置进程关闭参数
/// @param level 关闭级别
/// @param flags 标志位
/// @return 操作结果
int SetProcessShutdownParameters(uint level, uint flags);

/// 获取进程版本
/// @param process_id 进程ID
/// @return 进程版本
uint GetProcessVersion(uint process_id);

/// 获取启动信息
/// @param startup_info 返回的启动信息
void GetStartupInfoW(STARTUPINFOW &startup_info);

/// 设置进程优先级类别
/// @param process 进程句柄
/// @param priority_class 优先级类别
/// @return 操作结果
int SetPriorityClass(HANDLE process, uint priority_class);

/// 获取进程优先级类别
/// @param process 进程句柄
/// @return 优先级类别
uint GetPriorityClass(HANDLE process);

/// 设置线程堆栈保证大小
/// @param stack_size_in_bytes 堆栈大小(字节)
/// @return 操作结果
int SetThreadStackGuarantee(ulong stack_size_in_bytes);

/// 将进程ID转换为会话ID
/// @param process_id 进程ID
/// @param session_id 返回的会话ID
/// @return 操作结果
int ProcessIdToSessionId(uint process_id, uint &session_id);

/// 获取进程ID
/// @param process 进程句柄
/// @return 进程ID
uint GetProcessId(HANDLE process);

/// 获取线程ID
/// @param thread 线程句柄
/// @return 线程ID
uint GetThreadId(HANDLE thread);

/// 刷新进程写缓冲区
void FlushProcessWriteBuffers(void);

/// 获取线程所属进程ID
/// @param thread 线程句柄
/// @return 进程ID
uint GetProcessIdOfThread(HANDLE thread);

/// 初始化进程线程属性列表
/// @param attribute_list 属性列表
/// @param attribute_count 属性数量
/// @param flags 标志位
/// @param size 返回所需大小
/// @return 操作结果
int InitializeProcThreadAttributeList(PVOID attribute_list, uint attribute_count, uint flags, ulong &size);

/// 删除进程线程属性列表
/// @param attribute_list 属性列表
void DeleteProcThreadAttributeList(PVOID attribute_list);

/// 设置进程亲和性更新模式
/// @param process 进程句柄
/// @param flags 标志位
/// @return 操作结果
int SetProcessAffinityUpdateMode(HANDLE process, uint flags);

/// 查询进程亲和性更新模式
/// @param process 进程句柄
/// @param flags 返回的标志位
/// @return 操作结果
int QueryProcessAffinityUpdateMode(HANDLE process, uint &flags);

/// 更新进程线程属性
/// @param attribute_list 属性列表
/// @param flags 标志位
/// @param attribute 属性类型
/// @param value 属性值
/// @param size 值大小
/// @param previous_value 先前值
/// @param return_size 返回大小
/// @return 操作结果
int UpdateProcThreadAttribute(PVOID attribute_list, uint flags, uint attribute, PVOID value, ulong size, PVOID previous_value, ulong &return_size);

/// 在远程进程中创建线程(扩展)
/// @param process 远程进程句柄
/// @param thread_attributes 线程安全属性
/// @param stack_size 堆栈大小
/// @param start_address 线程函数地址
/// @param parameter 线程参数
/// @param creation_flags 创建标志
/// @param attribute_list 属性列表
/// @param thread_id 返回的线程ID
/// @return 线程句柄
HANDLE CreateRemoteThreadEx(HANDLE process, PVOID thread_attributes, ulong stack_size, PVOID start_address, PVOID parameter, uint creation_flags, PVOID attribute_list, uint &thread_id);

/// 获取当前线程堆栈限制
/// @param low_limit 返回堆栈低端地址
/// @param high_limit 返回堆栈高端地址
void GetCurrentThreadStackLimits(ulong &low_limit, ulong &high_limit);

/// 获取线程上下文
/// @param thread 线程句柄
/// @param context 返回的上下文
/// @return 操作结果
int GetThreadContext(HANDLE thread, CONTEXT &context);

/// 获取进程缓解策略
/// @param process 进程句柄
/// @param mitigation_policy 策略类型
/// @param buffer 缓冲区
/// @param length 缓冲区长度
/// @return 操作结果
int GetProcessMitigationPolicy(HANDLE process, PROCESS_MITIGATION_POLICY mitigation_policy, PVOID buffer, ulong length);

/// 设置线程上下文
/// @param thread 线程句柄
/// @param context 要设置的上下文
/// @return 操作结果
int SetThreadContext(HANDLE thread, const CONTEXT &context);

/// 设置进程缓解策略
/// @param mitigation_policy 策略类型
/// @param buffer 缓冲区
/// @param length 缓冲区长度
/// @return 操作结果
int SetProcessMitigationPolicy(PROCESS_MITIGATION_POLICY mitigation_policy, PVOID buffer, ulong length);

/// 刷新指令缓存
/// @param process 进程句柄
/// @param base_address 基地址
/// @param size 大小
/// @return 操作结果
int FlushInstructionCache(HANDLE process, const PVOID base_address, ulong size);

/// 获取线程时间信息
/// @param thread 线程句柄
/// @param creation_time 创建时间
/// @param exit_time 退出时间
/// @param kernel_time 内核时间
/// @param user_time 用户时间
/// @return 操作结果
int GetThreadTimes(HANDLE thread, FILETIME &creation_time, FILETIME &exit_time, FILETIME &kernel_time, FILETIME &user_time);

/// 打开进程
/// @param desired_access 访问权限
/// @param inherit_handle 是否可继承
/// @param process_id 进程ID
/// @return 进程句柄
HANDLE OpenProcess(uint desired_access, int inherit_handle, uint process_id);

/// 检查处理器特性支持
/// @param processor_feature 处理器特性
/// @return 是否支持
int IsProcessorFeaturePresent(uint processor_feature);

/// 获取进程句柄数量
/// @param process 进程句柄
/// @param handle_count 返回的句柄数量
/// @return 操作结果
int GetProcessHandleCount(HANDLE process, uint &handle_count);

/// 获取当前处理器编号
/// @return 当前处理器编号
uint GetCurrentProcessorNumber(void);

/// 设置线程理想处理器(扩展)
/// @param thread 线程句柄
/// @param ideal_processor 理想处理器
/// @param previous_ideal_processor 返回的先前的理想处理器
/// @return 操作结果
int SetThreadIdealProcessorEx(HANDLE thread, PROCESSOR_NUMBER &ideal_processor, PROCESSOR_NUMBER &previous_ideal_processor);

/// 获取线程理想处理器
/// @param thread 线程句柄
/// @param ideal_processor 返回的理想处理器
/// @return 操作结果
int GetThreadIdealProcessorEx(HANDLE thread, PROCESSOR_NUMBER &ideal_processor);

/// 获取当前处理器编号(扩展)
/// @param proc_number 返回的处理器编号
void GetCurrentProcessorNumberEx(PROCESSOR_NUMBER &proc_number);

/// 获取进程优先级提升状态
/// @param process 进程句柄
/// @param disable_priority_boost 返回的优先级提升状态
/// @return 操作结果
int GetProcessPriorityBoost(HANDLE process, int &disable_priority_boost);

/// 设置进程优先级提升状态
/// @param process 进程句柄
/// @param disable_priority_boost 是否禁用优先级提升
/// @return 操作结果
int SetProcessPriorityBoost(HANDLE process, int disable_priority_boost);

/// 获取线程I/O挂起标志
/// @param thread 线程句柄
/// @param io_is_pending 返回的I/O挂起状态
/// @return 操作结果
int GetThreadIOPendingFlag(HANDLE thread, int &io_is_pending);

/// 获取系统时间信息
/// @param idle_time 空闲时间
/// @param kernel_time 内核时间
/// @param user_time 用户时间
/// @return 操作结果
int GetSystemTimes(FILETIME &idle_time, FILETIME &kernel_time, FILETIME &user_time);

/// 获取线程信息
/// @param thread 线程句柄
/// @param thread_information_class 信息类别
/// @param thread_information 信息缓冲区
/// @param thread_information_size 信息大小
/// @return 操作结果
int GetThreadInformation(HANDLE thread, THREAD_INFORMATION_CLASS thread_information_class, PVOID thread_information, uint thread_information_size);

/// 设置线程信息
/// @param thread 线程句柄
/// @param thread_information_class 信息类别
/// @param thread_information 信息缓冲区
/// @param thread_information_size 信息大小
/// @return 操作结果
int SetThreadInformation(HANDLE thread, THREAD_INFORMATION_CLASS thread_information_class, PVOID thread_information, uint thread_information_size);

/// 检查进程是否关键
/// @param process 进程句柄
/// @param critical 返回的关键状态
/// @return 操作结果
int IsProcessCritical(HANDLE process, int &critical);

/// 设置受保护策略
/// @param policy_guid 策略GUID
/// @param policy_value 策略值
/// @param old_policy_value 返回的先前策略值
/// @return 操作结果
int SetProtectedPolicy(const GUID &policy_guid, ulong policy_value, ulong &old_policy_value);

/// 查询受保护策略
/// @param policy_guid 策略GUID
/// @param policy_value 返回的策略值
/// @return 操作结果
int QueryProtectedPolicy(const GUID &policy_guid, ulong &policy_value);

/// 设置线程理想处理器
/// @param thread 线程句柄
/// @param ideal_processor 理想处理器编号
/// @return 操作结果
uint SetThreadIdealProcessor(HANDLE thread, uint ideal_processor);

/// 设置进程信息
/// @param process 进程句柄
/// @param process_information_class 信息类别
/// @param process_information 信息缓冲区
/// @param process_information_size 信息大小
/// @return 操作结果
int SetProcessInformation(HANDLE process, PROCESS_INFORMATION_CLASS process_information_class, PVOID process_information, uint process_information_size);

/// 获取进程信息
/// @param process 进程句柄
/// @param process_information_class 信息类别
/// @param process_information 信息缓冲区
/// @param process_information_size 信息大小
/// @return 操作结果
int GetProcessInformation(HANDLE process, PROCESS_INFORMATION_CLASS process_information_class, PVOID process_information, uint process_information_size);

/// 获取系统CPU集信息
/// @param information 信息缓冲区
/// @param buffer_length 缓冲区长度
/// @param returned_length 返回的数据长度
/// @param process 进程句柄
/// @param flags 标志位
/// @return 操作结果
int GetSystemCpuSetInformation(SYSTEM_CPU_SET_INFORMATION &information, uint buffer_length, ulong returned_length, HANDLE process, uint flags);

/// 获取进程默认CPU集
/// @param process 进程句柄
/// @param cpu_set_ids 返回的CPU集ID
/// @param cpu_set_id_count CPU集ID数量
/// @param required_id_count 返回所需的ID数量
/// @return 操作结果
int GetProcessDefaultCpuSets(HANDLE process, ulong &cpu_set_ids, uint cpu_set_id_count, ulong required_id_count);

/// 设置进程默认CPU集
/// @param process 进程句柄
/// @param cpu_set_ids CPU集ID数组
/// @param cpu_set_id_count CPU集ID数量
/// @return 操作结果
int SetProcessDefaultCpuSets(HANDLE process, const uint &cpu_set_ids, uint cpu_set_id_count);

/// 获取线程选择的CPU集
/// @param thread 线程句柄
/// @param cpu_set_ids 返回的CPU集ID
/// @param cpu_set_id_count CPU集ID数量
/// @param required_id_count 返回所需的ID数量
/// @return 操作结果
int GetThreadSelectedCpuSets(HANDLE thread, ulong &cpu_set_ids, uint cpu_set_id_count, ulong required_id_count);

/// 设置线程选择的CPU集
/// @param thread 线程句柄
/// @param cpu_set_ids CPU集ID数组
/// @param cpu_set_id_count CPU集ID数量
/// @return 操作结果
int SetThreadSelectedCpuSets(HANDLE thread, const uint &cpu_set_ids, uint cpu_set_id_count);

/// 获取进程关闭参数
/// @param level 返回的关闭级别
/// @param flags 返回的标志位
/// @return 操作结果
int GetProcessShutdownParameters(uint &level, uint &flags);

/// 设置线程描述
/// @param thread 线程句柄
/// @param thread_description 线程描述
/// @return 操作结果
int SetThreadDescription(HANDLE thread, const string thread_description);

/// 获取线程描述
/// @param thread 线程句柄
/// @param thread_description 返回的线程描述
/// @return 操作结果
int GetThreadDescription(HANDLE thread, string &thread_description);
#import

#import "advapi32.dll"
/// 以用户身份创建进程
/// @param token 用户令牌
/// @param application_name 应用程序名
/// @param command_line 命令行
/// @param process_attributes 进程安全属性
/// @param thread_attributes 线程安全属性
/// @param inherit_handles 是否继承句柄
/// @param creation_flags 创建标志
/// @param environment 环境变量
/// @param current_directory 当前目录
/// @param startup_info 启动信息
/// @param process_information 进程信息
/// @return 操作结果
int CreateProcessAsUserW(HANDLE token, const string application_name, string command_line, PVOID process_attributes, PVOID thread_attributes, int inherit_handles, uint creation_flags, PVOID environment, const string current_directory, STARTUPINFOW &startup_info, PROCESS_INFORMATION &process_information);

/// 设置线程令牌
/// @param thread 线程句柄
/// @param token 令牌句柄
/// @return 操作结果
int SetThreadToken(HANDLE thread, HANDLE token);

/// 打开进程令牌
/// @param process_handle 进程句柄
/// @param desired_access 访问权限
/// @param token_handle 返回的令牌句柄
/// @return 操作结果
int OpenProcessToken(HANDLE process_handle, uint desired_access, HANDLE &token_handle);

/// 打开线程令牌
/// @param thread_handle 线程句柄
/// @param desired_access 访问权限
/// @param open_as_self 是否以自身身份打开
/// @param token_handle 返回的令牌句柄
/// @return 操作结果
int OpenThreadToken(HANDLE thread_handle, uint desired_access, int open_as_self, HANDLE &token_handle);
#import
//+------------------------------------------------------------------+